package com.moon.back.service.impl.file;


import cn.dev33.satoken.util.SaResult;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.moon.back.constant.FileOperaConstant;
import com.moon.back.context.UserContext;
import com.moon.back.dao.FileNodeDao;
import com.moon.back.entity.Req.FileQueryReq;
import com.moon.back.entity.Req.UploadFileReq;
import com.moon.back.entity.Resp.FileCommandOpreaResp;
import com.moon.back.entity.Resp.FileQueryResp;
import com.moon.back.entity.UserInfo;
import com.moon.back.entity.dto.*;
import com.moon.back.entity.file.FileNode;
import com.moon.back.service.IFileService;
import com.moon.back.util.*;
import org.apache.hadoop.fs.Path;
import org.beetl.sql.core.SQLManager;
import org.beetl.sql.core.SQLReady;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
import java.util.zip.ZipOutputStream;


/**
 * 实现 文件上传即可 这里要用到 vue-simple-loader 的组件
 *  实现 文件上传  断点续传  以及 文件夹上传 功能
 */

@Service
public class FileServiceImpl  implements IFileService {

    // 实现一个线程用来创建 CACHE_REBUILD_EXECUTOR
    // 线程池的使用会出问题
    private static final ExecutorService FILE_INSERT_EXECUTOR = Executors.newFixedThreadPool(20);
    private static final Logger log = LoggerFactory.getLogger(FileServiceImpl.class);

    @Autowired
    private FileNodeDao fileNodeDao;

    @Autowired
    private SQLManager sqlManager;

    @Autowired
    private HdfsUtil hdfsUtil;

    @Value(value = "${file.UploadPath}")
    private String UploadPath;

    @Autowired
    private IRefreshCacheService refreshCacheService;

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private CaffeineUtil<String,FileNode> caffeineUtil;

    /**
     * 上传  本地 和 hadoop 上
     * @param uploadFileReq
     * @return
     */
    @Override
    public SaResult fileUpload(UploadFileReq uploadFileReq) {
        MultipartFile file = uploadFileReq.getFile();
        String parentFilePath = uploadFileReq.getPath();
        // 好的现在拿到 token了 进行操作
        System.out.println("hdfs: "+uploadFileReq.getPath());
        if (file.isEmpty()) {
            return SaResult.error("错误,文件不存在");
        }
        int size = (int) file.getSize();
        if (size == 0) {
            return SaResult.error("文件为空");
        }
        File dest = new File(UploadPath  + file.getOriginalFilename());
        //判断文件父目录是否存在
        if (!dest.getParentFile().exists()) {
            Boolean mkdir = dest.getParentFile().mkdir();
            if(BooleanUtil.isTrue(mkdir)){
                log.info("父文件夹创建成功");
            }else {
                log.info("父文件夹创建失败");
            }
        }
        UserInfo userInfo = UserContext.getUserInfo();
        String username = userInfo.getUsername();
         //本地存储路径
        Path path = new Path( dest.getPath());
        try {
            file.transferTo(dest);
            // 获取父节点路径
              // 从最后一个'/'后截取字符串 这里不需要截取
            if(parentFilePath.isEmpty()){
                parentFilePath = "/"+username;
            }
            // TODO 文件上传时可能判断下当前文件目录下是否存在相同的文件
            // hdfs 上传
            hdfsUtil.upload(path, parentFilePath,  file.getOriginalFilename());
             // 获取父节点的文件信息
            FileNode fileNodeParent = fileNodeDao.createQuery()
                    .andEq("file_path",parentFilePath ).single();

            FileNode fileNode = FileNode.builder().build();
            // 判断文件 类型
            int type = TypeJudgeUtil.typeJudge(file.getOriginalFilename());
            // 设置文件的备份的数量
            fileNode.setReplication(3);
            //父文件节点ID
            fileNode.setFileParentId(fileNodeParent.getFileId());
            long chunkSize =  file.getSize();
            double chunkSize2 = (double)  chunkSize;
            // 转化为kb
            chunkSize2 = chunkSize2 /1024;
            double chunkD = Double.parseDouble(String.format("%.3f", chunkSize2));
            //  chunkSize 大小判断
            fileNode.setFileSize(chunkD);
            fileNode.setFileName(file.getOriginalFilename());
            fileNode.setFileType(type);
            fileNode.setAccessTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                    .format(new Date()));

            fileNode.setIsExist(1);
            fileNode.setIsDirectory(Boolean.FALSE);
            fileNode.setFileParentId(fileNodeParent.getFileId());
            // 设置文件路径 hdfs的路径
            fileNode.setFilePath(  parentFilePath+'/'+file.getOriginalFilename());
            String[] split = parentFilePath.split("/");
            // 更新父文件夹的大小
            for (String s : split) {
                FileNode f = fileNodeDao.createQuery().andEq("file_name",s).single();
                if(ObjectUtil.isNotNull(f)) {
                    f.setFileSize(f.getFileSize()+chunkD);
                    // 更新文件夹大小
                    fileNodeDao.updateById(f);
                }
            }
            // 文件信息更新
            this.fileNodeDao.insert(fileNode);

        } catch (IllegalStateException | IOException e) {
            e.printStackTrace();
            return SaResult.data(dest);
        }
        return SaResult.data(dest);
    }

    public Integer getFilePageStartIndex(Integer pageNum,Integer pageSize) {
      return  (pageNum-1)*pageSize+1;
    }

    /**
     * 获取 文件
     * @param request
     * @param fileQueryReq
     * @return
     */
    @Override
    public SaResult getFile(HttpServletRequest request, FileQueryReq fileQueryReq) {

      UserInfo userInfo = UserContext.getUserInfo();
      FileQueryResp fileQueryResp = PageUtils.getPageReps(fileQueryReq);
      Integer startIndex = this.getFilePageStartIndex(fileQueryReq.getPageNum(),fileQueryReq.getPageSize());
      // 或者传入的是一个根目录
      if(ObjectUtil.isEmpty(fileQueryReq.getPath())||fileQueryReq.getPath().equals("/"+userInfo.getUsername()) ){
         FileNode fileNode = fileNodeDao.createQuery()
                 .andEq("file_path", "/" + userInfo.getUsername()).single();
         // 表示未加入到回收站的文件
          setTotal(fileQueryResp, fileNode);

          List<FileNode> fileParentId = fileNodeDao.createQuery()
                 .andEq("file_parent_id", fileNode.getFileId())
                 .andEq("is_exist",1)
                 .limit(startIndex,fileQueryReq.getPageSize())
                 .select();
          fileQueryResp.setDataList(fileParentId);
         return SaResult.data(fileQueryResp);
      }

        /***
         * 达到当前节点的 id 值
         */
     FileNode fileNode =  fileNodeDao.createQuery()
             .andEq("file_path",fileQueryReq.getPath()).single();

     setTotal(fileQueryResp, fileNode);
        /***
         * 以当前节点为父节点查询下级
         */
     List<FileNode> fileList = fileNodeDao.createQuery()
                .andEq("file_parent_id", fileNode.getFileId())
                .limit(startIndex,fileQueryReq.getPageSize())
                .select();
    fileQueryResp.setDataList(fileList);

     return SaResult.data(fileQueryResp);
    }


    /**
     *   获取分页总数
     */

    public void setTotal(FileQueryResp fileQueryResp ,FileNode fileNode) {
        Long totalFileNum = fileNodeDao.createQuery()
                .condition()
                .andEq("file_parent_id", fileNode.getFileId())
                .andEq("is_exist",1)
                .count();

        fileQueryResp.setTotal(totalFileNum);
    }

    /**
     * 获取指定类型文件
     *
     * @param request
     *
     * @param fileTypeDto
     * @return
     */
    @Override
    public SaResult getAllFileType(HttpServletRequest request, FileTypeDto fileTypeDto) {
        UserInfo userInfo = UserContext.getUserInfo();
        String username = userInfo.getUsername();
        FileQueryResp fileQueryResp = PageUtils.getPageReps(fileTypeDto);
        Integer startIndex = this.getFilePageStartIndex(fileTypeDto.getPageNum(),fileTypeDto.getPageSize());

        if(ObjectUtil.isNull(fileTypeDto.getType())){
            return SaResult.data(fileQueryResp);
        }

        List<FileNode> list;
        // fileType == 8 表示要加入回收站的文件
        if(fileTypeDto.getType() == 8){

//            list=refreshCacheService
//                    .queryOrRefresh("query-dir-files"
//                            ,()-> fileNodeDao.createQuery()
//                                    // 这里应该是用户节点下的所有文件
//                                    .andLike("file_path", '%'  + username+'%')
//                                    .limit(startIndex,fileTypeDto.getPageSize())
//                                    // 逻辑不存在 回收站中的文件
//                                    .andEq("is_exist",0)
//                                    .select());

            list = fileNodeDao.createQuery()
                    // 这里应该是用户节点下的所有文件
                    .andLike("file_path", '/' + username+'%')
                    .limit(startIndex,fileTypeDto.getPageSize())
                    .andNotEq("file_path","/"+username)
                    // 逻辑不存在 回收站中的文件
                    .andEq("is_exist",0)
                    .select();

        }else{

//            list=refreshCacheService
//                    .queryOrRefresh("query-dir-files"
//                            ,()-> fileNodeDao.createQuery()
//                                    // 这里应该是用户节点下的所有文件
//                                    .andLike("file_path", '%'  + username+'%')
//                                    .limit(startIndex,fileTypeDto.getPageSize())
//                                    // 逻辑不存在 回收站中的文件
//                                    .andEq("is_exist",0)
//                                    .select());

            list= fileNodeDao.createQuery()
                    .andLike("file_path",'/' + username+'%')
                    // 逻辑存在
                    .andNotEq("file_path","/"+username)
                    .andEq("is_exist",1)
                    .limit(startIndex,fileTypeDto.getPageSize())
                    .andEq("file_type", fileTypeDto.getType())
                    .select();
        }
        fileQueryResp.setDataList(list);
        setTypeTotal(fileQueryResp,fileTypeDto.getType());
        return SaResult.data(fileQueryResp);
    }
    /**
     * 设置类型查询的分页文件总数
     * @param fileQueryResp
     * @param type
     */
    @Override
    public void setTypeTotal(FileQueryResp fileQueryResp, Integer type) {
        Long totalFileNum = fileNodeDao.createQuery()
                .andEq("file_type",  type)
                .andEq("is_exist",1)
                .count();

        fileQueryResp.setTotal(totalFileNum);
    }
    /**
     * 新建文件夹
     *
     * @param request
     * @param folderDto
     * @return
     */
    @Override
    public SaResult newDir(HttpServletRequest request, FolderDto folderDto) {
        UserInfo userInfo = UserContext.getUserInfo();
        String username = userInfo.getUsername();
        String dirPath = folderDto.getCurrentPath();


        // 如果不是以用户名开头的，则加上用户名 这点前后都要加"/" 否则会有BUG
        if(!dirPath.contains("/"+username+"/") ){
            dirPath = '/'+username+dirPath;
        }

        if (hdfsUtil.mkdir(username, dirPath)) {
            String finalDirPath = dirPath;
            // 文件的异步插入操作
           refreshCacheService
                    .insertData("new-dir-insert"
                            ,()-> this.insertNewFolder(finalDirPath));
           return SaResult.data(dirPath);
        }
        return SaResult.error("文件创建失败");
    }

    public Integer insertNewFolder(String finalDirPath){
//        FILE_INSERT_EXECUTOR.execute(()->{
            // 这里的逻辑要变
            FileNode fileNode =  FileNode.builder().build();
            int i = finalDirPath.lastIndexOf('/');
            String parent = finalDirPath.substring(0,i);
            // 获取父节点
            FileNode fileParentNode = this.fileNodeDao.createQuery()
                    .andEq("file_path", parent).single();

            String[] split = finalDirPath.split("/");
            fileNode.setFileSize(0.0);
            fileNode.setFileName(split[split.length-1]);
            fileNode.setIsExist(1);
            fileNode.setIsDirectory(Boolean.TRUE);
            fileNode.setAccessTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            fileNode.setFileType(0);
            // 需要查询到父节点的ID ? 从前端返回来也可
            fileNode.setFileParentId(fileParentNode.getFileId());
            fileNode.setFilePath(finalDirPath);
            // 这个操作数据库的操作可以通过线程池的方式 来优化

            // 查找是否有相同的文件夹
            if(this.fileNodeDao.existFolder(finalDirPath) >0 ) {
                SimpleDateFormat formatter = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss");
                Date date = new Date(System.currentTimeMillis());
                String nowDate = formatter.format(date);
                String fileName = fileNode.getFileName();
                fileNode.setFileName(fileName +'_'+ nowDate);
                System.out.println(formatter.format(date));
            }

        try {
            fileNodeDao.insert(fileNode);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return 1;
    }



    /**
     * 文件重命名
     * @param request
     * @param fileChangeNameDto
     *
     * @return
     */
    @Override
    public SaResult changeFileName(HttpServletRequest request, FileChangeNameDto fileChangeNameDto) {

        if (fileChangeNameDto.getPath() == null
                || fileChangeNameDto.getOldName() == null
                || fileChangeNameDto.getNewName() == null) {
            SaResult.error("文件名错误");
        }

        UserInfo userInfo = UserContext.getUserInfo();
        String username = userInfo.getUsername();

        // 数据更改
        FileNode fileChange = this.fileNodeDao.createQuery()
                .andEq("file_id", fileChangeNameDto.getFileId()).single();

        if(ObjectUtil.isNotNull(fileChange)){
            fileChangeNameDto.setOldName(fileChange.getFileName());
        }



        // 文件路径
        String path = fileChange.getFilePath();
        int i = path.lastIndexOf('/');
        String upPath = path.substring(0, i);

        String oldFileName =  fileChange.getFileName();
        String[] split = oldFileName.split("\\.");

        // 将新文件名称与文件后缀做拼接
        // 首先要判断是否是文件夹
        String newFileName = BooleanUtil.isFalse(fileChange.getIsDirectory())
                ?fileChangeNameDto.getNewName()+"."+split[1]:fileChangeNameDto.getNewName();
        // 文件夹处理 这时候要将文件路径都更新一下
//        if(BooleanUtil.isTrue(fileChange.getIsDirectory())){
//            this.fileNodeDao.renameByParentFilePath(oldFileName, newFileName,fileChange.getFilePath());
//        }
        if (hdfsUtil.changeFileName(username, upPath,
                fileChangeNameDto.getOldName(),
                newFileName )) {
            //
            fileChange.setFileName(newFileName);
            // 名称修改的同时要修改路径
            String filePath = fileChange.getFilePath();
            int i1 = filePath.lastIndexOf('/');
            fileChange.setFilePath( filePath.substring(0, i1 +1)+newFileName);
            // 名称修改
            this.fileNodeDao.updateById(fileChange);
            // 文件路径的修改

           return SaResult.ok("修改成功!");
        }

        return SaResult.error("修改失败!");
    }


    /**
     * 实现 文件 的 批量删除
     * @param request
     * @return
     */
    @Override
    public SaResult delFileAll(HttpServletRequest request){
        return SaResult.ok();
    }

    /**
     * 删除文件
     * @param request
     * @param delFileDto
     * @return
     */
    @Override
    public SaResult delFile(HttpServletRequest request, DelFileDto delFileDto) {

        UserInfo userInfo = UserContext.getUserInfo();
        String username = userInfo.getUsername();

        FileNode fileNode = fileNodeDao.createQuery().andEq("file_id", delFileDto.getFileId()).single();

//        if(BooleanUtil.isTrue(fileNode.getIsDirectory())){
////            if(fileNode.get)
////            this.fileNodeDao.
//            return SaResult.ok("抱歉，文件夹不支持删除操作");
//        }

        // 逻辑删除

        if(delFileDto.getType()==0){
            fileNode.setIsExist(0);
            int res = fileNodeDao.updateById(fileNode);
            if(res>0){
                return SaResult.ok("删除成功!");
            }else{
                return SaResult.error("删除失败!");
            }
       }
        // 文件夹的物理删除 通过 file_path去筛选
        // 物理删除

        if( delFileDto.getType() == 1) {
            int res;
            if (BooleanUtil.isTrue(fileNode.getIsDirectory())) {
                res = fileNodeDao.createQuery().andLike("file_path", fileNode.getFilePath() + "%").delete();
            } else {
                res = fileNodeDao.createQuery().andEq("file_id", fileNode.getFileId()).delete();
            }

            //物理删除
            if (res > 0) {
                log.info("文件删除成功");
                log.info("文件名称: {}", fileNode.getFileName());
                File file = new File(UploadPath + fileNode.getFileName());
                //  hadoop 文件的删除
                boolean deleteFlag = hdfsUtil.delete(username, fileNode.getFilePath());

                log.info("HDFS文件删除结果: {}", deleteFlag);
                // 相当于本地的一个弱备份
                if(BooleanUtil.isFalse(fileNode.getIsDirectory())){
                    boolean delete = file.delete();
                }

                if (delFileDto.getType() == 1
                        && deleteFlag
                ) {
                    int i = fileNodeDao.deleteById(fileNode.getFileId());
                    log.info("文件删除结果: {}", i);
                    return SaResult.ok("删除成功!");
                }
            }
            return SaResult.error("删除失败!");
        }
        return SaResult.ok("删除成功!");
    }

    /**
     * 删除文件夹
     * @param delFileDto
     * @return
     */



    /**
     * 这里的批量删除只支持逻辑删除
     * @param delFileBatchDto
     */
    @Override
    public SaResult delFileBatch(DelFileBatchDto delFileBatchDto) {
        // 获取fileId
        Integer[] fileIds = delFileBatchDto.getFileIds();
        List<Integer> fileIdList = Arrays.stream(fileIds)
        .collect(Collectors.toCollection(Arrays::asList));

       if(ObjectUtil.isNotEmpty(fileIdList)){
         return fileNodeDao.createQuery().andIn("file_id", fileIdList).update("set is_exist=0")>0
                 ? SaResult.ok("删除成功!!!") : SaResult.ok("删除失败!!!");
        }
       return  SaResult.ok("删除失败!!!");
    }


    /**
     * 文件恢复
     *  设置相关的刷新参数
     * @param refreshDto
     * @return
     */
    @Override
    public SaResult refresh(RefreshDto refreshDto){
        FileNode file = this.fileNodeDao.createQuery()
                .andEq("file_id", refreshDto.getFileId()).single();
        // 设置恢复
        file.setIsExist(1);
        int res = this.fileNodeDao.updateById(file);
        if(res>0){
            return SaResult.ok("文件恢复成功");
        }
        return SaResult.error("文件恢复失败");
    }

    /**
     * 下载文件
     * @param request
     * @param fileId
     * @return
     */
    @Override
    public ResponseEntity<InputStreamResource> downFile(HttpServletRequest request, String fileId) throws IOException {
       // 通过ID  进行文件查询 和下载
        FileNode file =   fileNodeDao.createQuery().andEq("file_id", fileId).single();

        ResponseEntity<InputStreamResource> res = null;

        // 文件夹的下载
        if(file!=null&& file.getIsDirectory().equals(true) ){
            String folderPath = file.getFilePath();
            // 创建临时 ZIP 文件
            String fileName = file.getFileName();
            File zipFile = File.createTempFile(fileName, ".zip");

            try (FileOutputStream fos = new FileOutputStream(zipFile);
                 ZipOutputStream zos = new ZipOutputStream(fos)) {
                hdfsUtil.zipHdfsFolder(folderPath, zos);
            }

            // 返回 ZIP 流
            InputStream inputStream = new FileInputStream(zipFile);
            HttpHeaders headers = new HttpHeaders();
            headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename="+fileName+".zip");
            headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_OCTET_STREAM_VALUE);

            // 删除临时文件（可选）
            zipFile.deleteOnExit();

            return ResponseEntity.ok()
                    .headers(headers)
                    .contentLength(zipFile.length())
                    .body(new InputStreamResource(inputStream));
        }


        try {
            res = hdfsUtil.downFile(file.getFileName(), file.getFilePath());
        } catch (Exception e) {
            e.printStackTrace();
        }

        return res;
    }

    /**
     * 查看 预览 图片
     *
     * @param path
     * @param request
     * @param resp
     * @return
     * @throws IOException
     */
    @Override
    public SaResult lookImage(String path, HttpServletRequest request, HttpServletResponse resp) throws IOException {
        ;
        if (EmptyUtil.isEmpty(path)) {
            SaResult.error("查看失败!");
        } else {
            UserInfo userInfo = UserContext.getUserInfo();

            String name = userInfo.getUsername();
            path = "/" + name + path;
            hdfsUtil.outputImage(resp, path);
            SaResult.ok("获取文件成功!");
        }

        return SaResult.error("查看失败!");
    }

    /**
     * 查看预览 文档
     *
     * @param path
     * @param request
     * @param resp
     * @return
     * @throws IOException
     */
    @Override
    public SaResult lookDoc(HttpServletRequest request, HttpServletResponse resp, String path) throws IOException {

        if (EmptyUtil.isEmpty(path)) {
            SaResult.error("查看失败!");
        } else {
            UserInfo userInfo = UserContext.getUserInfo();

            String name = userInfo.getUsername();
            path = "/" + name + path;

            SaResult.data(hdfsUtil.lookDoc(path));

        }
        return SaResult.error("查看失败!");
    }

    @Override
    public SaResult fileHandlerToMatch(Integer operaSign, String fileNameSuffix, String fileNameStr) {

        switch (operaSign) {
            case 1:

            case 2:


                break;
        }

        return null;
    }

    /**
     *  获取  HADOOP 服务器信息
     * @return
     */
    public SaResult LookHdfs() {
        return SaResult.ok();
    }


    /**
     *  处理的东西
     *
     * @
     * @param fileOperaEntity 文件的指令操作的实体封装
     * @return
     */
    @Override
    public SaResult fileMatchHandler(FileOperaDto fileOperaEntity) {

        StringBuffer sqlBuffer = new StringBuffer();

        // select * from user
        // update from  user where
        // delete from user

        sqlBuffer.append(FileOperaConstant.OPERA_SQL[fileOperaEntity.getOperaSign()]);

        Boolean isContainOpera = fileOperaEntity.getIsContainOpera();
        Integer isContainType = fileOperaEntity.getIsContainType();

        if(BooleanUtil.isTrue(isContainOpera)){
            sqlBuffer.append(FileOperaConstant.CONTAINS_SQL);
        }else{
            sqlBuffer.append(FileOperaConstant.EQUAL_SQL);
        }

        if(isContainType!=-1 && isContainType<2){
            fileOperaEntity.setFileNameStr( FileOperaConstant.LIKE_SQL+fileOperaEntity.getFileNameStr()+ FileOperaConstant.LIKE_SQL);

        }else if(isContainType == 2){
          fileOperaEntity.setFileNameStr(fileOperaEntity.getFileNameStr()+ FileOperaConstant.LIKE_SQL);

        } else if (isContainType == 3) {
            fileOperaEntity.setFileNameStr(FileOperaConstant.LIKE_SQL+fileOperaEntity.getFileNameStr());

        }

        log.info("分析获取的sql: {}", sqlBuffer);
        SQLReady sqlReady = new SQLReady(sqlBuffer.toString(),fileOperaEntity.getFileNameStr());
        Object execute = sqlManager.execute(sqlReady, FileNode.class);


        if(execute instanceof List){
            log.info("查询结果: {}", execute);
        }else{
            log.info("删除结果: {}", execute);

        }
        FileCommandOpreaResp fileCommandOpreaResp = new FileCommandOpreaResp();

        fileCommandOpreaResp.setOperaSign(fileOperaEntity.getOperaSign());
        fileCommandOpreaResp.setRes(execute);
        fileCommandOpreaResp.setMsg("指令操作成功." + (fileOperaEntity.getOperaSign() ==2? "删除成功":"查找成功"));
        return SaResult.data(fileCommandOpreaResp);

    }

}
